1. Field of the Invention
The present invention concerns improvements in debugging support devices and debugging support methods for supporting the debugging of object-oriented programs and particularly concerns a support device and method which are suited to the debugging of object-oriented programs for parallel processing systems.
2. Description of the Prior Art
Since a computer program is a complex set of data processing procedures, it is actually very difficult to completely prevent the occurrence of errors in a program in its development or modification, even if the developer takes the utmost care. Thus, the developer must test a tentatively completed program and eliminate the errors (bugs) in order to increase the reliability of the program.
A debugging support device, using a debugging support method is a device which supports debugging operations and such a device supports efficient debugging of a program through functions which, for example, (1) indicate the part of the program being executed, (2) display execution information concerning the program execution (e.g. contents of the register and memory, etc.), (3) break (stop) the execution of the program at places (breakpoints) designated by the user, and (4) record the debugging history such as the user""s instructions and execution information, while the program to be debugged is being executed and stopped according to the operations by the user.
Conventionally, programs were designed using data processing procedures. Data was structured in accordance with the processing procedure, and as a separate entity from the processing procedures. Such programs designed using processing procedures are called procedural programs. In such procedural programs, the source code (the program expressed in a specific programming language), which is written one statement (unit of expression, such as a declaration or an instruction) at a time, directly expresses the data processing procedures in the computer during the execution of the program.
Thus, conventional debugging support devices supported debugging by showing the part of the program being executed, by setting breakpoints, by recording the debugging history, etc. while using the statement or the line (in the source codes) as the smallest unit to be debugged.
On the other hand, object-oriented programming has become popular in recent years as a new software development means. Throughout the specification, object-oriented programming refers to a means where the actual entity to be processed by the software is expressed as an xe2x80x9cobjectxe2x80x9d. An object is a software entity where the elements that make up the structure of the object and the processing procedures which operate on those elements are respectively defined as data or attributes, and methods, processing procedures or functions. For example, one type of method is an xe2x80x9coperationxe2x80x9d method that operates on the data.
Programs written using object-oriented programming techniques are called object-oriented programs. In an object-oriented program, a plurality of objects, corresponding to actual entities, operate cooperatively, processing information. That occurs because of the relationships between actual entities can be easily realized on a computer. As a result, the information structure of actual entities is simulated in the software structure and software can be realized which has a clear structure and which is maintainable. Furthermore, since the contents of each module which comprises the program becomes easier to understand objectively, it becomes generally easier to make improvements in the encapsulation and reusability of each module.
Such object-oriented programming is performed with an object-oriented programming language such as Smalltalk or C++ and is generally designed using object-oriented design techniques in which programs are developed module by module.
Conceptually speaking, the program becomes a set of objects in such an object-oriented program. These objects are instantiated in the computer only during the execution of the program and the data of an object is assigned specific values only after being mapped to a memory block in the computer.
Thus, the development of a program is, for the sake of convenience, performed in the form of source code even in object-oriented programming. However, the source code in object-oriented programming is a set of class definitions which describe the characteristics of an object. Here, a xe2x80x9cclass definitionxe2x80x9d refers to a module of a program which describes the data of an object and the operations to be performed on such data. Since this class definition serves as a basis for instantiating objects, which are entities, a plurality of instances of an object may be instantiated from a single class definition. However, once objects are instantiated, they are, as a rule, separate and independent of each other and the data contents for each individual object is self-contained.
As described above, object-oriented programming is a means by which the series of methods necessary for the execution of a specific program and the data used in such a program are handled as a single unit called an object and by which a program is formed by using objects as the base execution unit.
In recent years, object-oriented programming has gained attention as a new technique that is particularly suited for programming in parallel processing system environments in which a plurality of processors perform multiple processing operations in an asynchronous manner.
In an object-oriented program, the methods and data that constitute each object cannot be freely accessed by other objects. Thus, in order to perform the operations of an object-oriented program, a structure is required by which the data necessary for the execution of the program is instantiated and then accessed using at least one method of the instantiated object.
To create such a structure, messages which invoke the methods of one object are sent by another object. That is, when a method or a part of a method is completed at one object, this object transmits a message indicating the execution thereof to another object in charge of a different part of a program or the next method. Contained in this message is information such as the name of the method to be invoked by the message-receiving object, the argument (parameter) to be passed to the method when making the method, etc.
Upon receiving a message correctly, the receiving object executes a method in accordance with the contents of the message and, when the process is ended without any problem, returns a prescribed return value as a reply message to the message-sending object as necessary. Each object can thus interoperate as expected by sending and receiving messages. On the other hand, if the program does not function as expected, the object which behaves abnormally can be found by examining and tracing the contents of messages sent and received by each object.
The debugging means in object-oriented programming are based on the concepts described above, and, in general, the operation of the entire program is investigated by examining a record (hereinafter referred to as an event history) of messages exchanged between objects during the execution of the program. As an example of where such a means is applied, there is a system in which the object to be debugged (hereinafter referred to as the debug target object) is specified and the recording object (hereinafter referred to as the debugger object) for recording the event history are set so that all messages sent and received by the debug target object are sent to and recorded by the debugger object.
However, problems arise when debugging specific objects and object-oriented application programs with conventional debugging means in parallel processing systems. With a conventional debugging means, a suitable object is selected and all messages sent and received by the object are recorded. In this case, numerous messages which are unrelated to the object or application program to be debugged are recorded in the debugger object. This arises as a result of said object being commonly possessed by a plurality of different objects and application programs.
In other words, a program generally contains relatively upper-ranking overall methods and relatively simple and specific lower-ranking methods which are components of the upper-ranking methods. In an object-oriented methods, the upper-ranking methods and lower-ranking methods are implemented as separate objects and the upper-ranking methods request services from lower-ranking methods by sending messages to the objects performing the lower-ranking methods. Objects which comprise a part of the function of another object by being called by the other object are called member objects with respect to the other object which does the calling.
When debugging is performed for a specific object, the information that is mainly needed is the messages sent and received between the central object and the peripheral objects. xe2x80x9cPeripheralxe2x80x9d objects refer to objects that have a close relationship with the central object and, to be more specific, include objects which are directly called by the central object as a member and grandchild or great-grandchild object which are indirectly called by such member objects. Thus, to be specific, in the debugging of an object-oriented program, the messages sent and received by a central object and its peripheral objects are recorded.
However, an object that is called as a member by the central object may also be subsequently called as a member of a different object. Furthermore, in a parallel processing system environment, the member of a central object may be called as member of an object of another application program. In such cases, even if the object that is to be the center and its peripheral objects are designated inside one program, the recorded messages will include messages sent and received between other objects outside the targeted range.
It thus becomes necessary to perform the extremely troublesome task of selecting from among a vast amount of message information recorded in the debugger object only those messages that relate to the object or application program targeted for debugging. Furthermore, previously effective means for selectively recording messages that relate only to the object or application program targeted for debugging have not been created.
The present invention has been proposed to solve such problems of the conventional art as described above and the object thereof is to present a debugging support device and debugging support method which would make the debugging of object-oriented programs more efficient. Another object of the present invention is to present a debugging support device and debugging support method which can be implemented easily.
To be more specific, a first object of the present invention is to present a debugging support method by which the objects targeted for debugging can be identified as necessary.
A second object of the present invention is to present a debugging support method by which the debug target objects can be distinguished from other objects without increasing the scale of the device.
A third object of the present invention is to present a debugging support device equipped with specific means for realizing the above-mentioned second object.
A fourth object of the present invention is to present a debugging support device that designates the specific objects to be debugged.
A fifth object of the present invention is to present a debugging support device which records, in the debugger object, the history only of events sent and received by objects designated as an object to be debugged.
A sixth object of the present invention is to present a debugging support device which can express the priorities of the debugging operations for each object within the objects to be debugged in a relative manner by the use of numerical values within a prescribed range.
A seventh object of the present invention is to present a debugging support device for performing a debugging operation only on objects having a range of numerical values within said prescribed range.
An eighth object of the present invention is to present a debugging support device which, upon the sending of a message in each object within the debug target range, redesignates the above-mentioned priority of the debugging operation for the next object.
A ninth object of the present invention is to present a debugging support device which can express the position of the next object, which is to be the destination of the above-mentioned message, in a relative manner using the above-mentioned prescribed numerals which express the priorities of the debugging operation.
A tenth object of the present invention is to present a debugging support device which, when a message is received by an object which is to be debugged, records the priorities of the debugging operation concerning said object.
An eleventh object of the present invention is to present a debugging support device which sends the messages, sent and received by each object which is to be discussed, to a designated debugger object.
In order to accomplish the above objects, a first illustrative implementation of the present invention implements a debugging support device for supporting the debugging of an object-oriented program containing at least one object, each of said at least one objects having a sending means which sends messages between said at least one object, and a receiving means which receives said messages. The debugging support device comprises a designation means, which designates an object among said objects of said at least one object-oriented program to be a central object to be targeted for debugging; a detection means, which detects as relevant messages both direct messages and indirect messages that are relevant to said central object, wherein said direct messages are sent and received by said central object, and said indirect messages are messages sent and received as a result of said direct messages; and recording means for recording said relevant messages that are detected.
The debugging support method of the present invention enables the debugging of an object-oriented program containing at least one object, each of said at least one object performing a sending process by which messages are sent between at least one of said at least one object and a receiving process by which said messages are received, comprising the steps of: designating an object from among plural objects of an object-oriented program to be a central object to be targeted for debugging, detecting as relevant messages those direct messages and indirect messages relevant to said central object wherein said direct messages are messages sent and received by said central object and said indirect messages are messages sent and received as a result of said direct messages; and recording said relevant messages that are detected.
Using the present invention the relevant messages, including direct messages, are detected and recorded. In general, an object that is called as a member by the central object at some point may behave as a member of a different object at a different point in time. Since the relevant messages to be recorded are sent or received as a result of a direct message, such messages are useful in the analysis of the actions performed for the central object by a called object. On the other hand, when this called object behaves as a member of another object, it is unrelated to the central object. The message in such a case is not included among the relevant messages and is not recorded. Since only the messages related to the central message are thus recorded, the trouble of finding the records of the necessary messages is eliminated and debugging is made efficient.
In a second illustrative implementation of the present invention, the previous embodiment is further refined so that said detection means comprises: a member designation means, which designates said objects that have received said relevant message to be a member of said central object, a cancellation means, which cancels said designation of said object as a member when said object has completed the process requested by the received relevant message, and a judging means, which judges that the message sent by said object designated as a members to be one of the said relevant messages.
A method that performs the functions of the above embodiment uses a detecting step that comprises: a member designation process by which the objects that have received said relevant message are designated as a member of said central object, a cancellation process by which, when said object has completed the process requested by the received relevant message, said designation of said object as a member is canceled and a judging process by which it is judged that the message sent by said object designated as a member is one of the said relevant messages.
In the second illustrative implementation and its method which has received a relevant message is designated as a member until the process requested by said relevant message has been completed. The messages sent by said object while said object is designated as a member are also regarded as relevant messages. The same process is also performed on objects receiving relevant messages from members.
The designation as a member may be realized, for example, by securing a flag block corresponding to each instance and raising this flag while an object is designated as a member. This implementation and its method eliminate the need to trace the transmission path of the message to confirm the relationship of each message with the central object in order to judge whether or not the message is a relevant message, even when the range of relevant messages resulting from a direct message expands. Instead, by repeating the above-mentioned simple process, the range of relevant messages may be specified easily and infallibly.
The third illustrative implementation is a debugging support device as described in the first illustrative implementation, wherein said recording metgod comprises: a debugger object for recording said messages, and a second sending means, which sends said relevant messages to said debugger object.
The debugging support method of the first illustrative implementation implements said recording process using: a debugger object for recording said message and a second sending process by which said relevant message are sent to said debugger object.
The method may be further implemented to record the message in an object. Thus these inventions are excellent in compatibility with the processing system of an object-oriented program itself and may be implemented easily.
The third illustrative implementation and its method may be augmented to form a fourth illustrative implementation by including a destination designation means which designates said debugger object.
With the fourth illustrative implementation and its method, since the debugger object can be designated freely, different debugger objects may be used according to each target object or be used sequentially each time a test is performed in order to organize the information and make the debugging operation efficient.
The fifth illustrative implementation augmanets the first illustrative implementation by including: a counting means, which counts the distance of each of said relevant messages from said central object based on the number of said messages or said objects passed through to get from said central object to said relevant message, and a restricting means, which restricts said relevant messages to be recorded based on said distance counted.
The debugging support method of the fifth illustrative implementation further includes a counting process by which the distance of each of said relevant messages from said central object is counted based on the number of said messages or said objects passed through to get from said central object to said relevant message and a restricting process by which said relevant messages to be recorded is restricted based on said distance counted.
In the execution of an object-oriented program, messages are sequentially transferred from an object to the next object. Debugging is made efficient by the fifth illustrative implementation and its method since the relevant messages to be recorded are limited to those which are not far in distance from the central object. For example, if the recording target is limited to messages of objects that are away from the central object by a distance of 2, the messages by which the central object directly calls a member object and the messages by which the called member calls a grandchild object are recorded.
The sixth illustrative implementation augments the fifth illustrative implementation by further comprising a range designation means which designates the range of said messages to be recorded by designating said distance, involved with said restriction, from said central object. The debugging support method of the sixth illustrative implementation utilizes a range designation process by which the range of said messages to be recorded is designated by designating said distance, involved with said restriction, from said central object.
With the sixth illustrative implementation and its method, since the range of messages to be recorded can be designated by the distance from the central object, the range of recorded messages can be changed in a maneuverable manner according to the debug target and the debugging can thus be made efficient. For example, if the relevant messages to be recorded are designated to be those for which the distance from the central object is short, the messages recorded can be restricted to those having an especially close relationship with the central object. Oppositely, if messages for which the distance from the central object is far are recorded, operations may be tracked over a wide range.
The seventh illustrative implementation augments the fifth illustrative implementation by further including an output means, which outputs each of said messages recorded and each of said objects involved in the sending and receiving of said messages by depicting said messages and said objects in a manner whereby they are centered about said central object and are positioned further outwards the greater the said distance from said central object.
The debugging support method of the seventh illustrative implementation utilizes an output process by which each of said messages recorded and each of said objects involved in the sending and receiving of said messages are output by depicting said messages and said objects in a manner whereby they are centered about said central object and are positioned further outwards the greater the said distance from said central object.
With the seventh illustrative implementation and its method, each of said recorded messages and the objects involved in the sending and receiving of each message are output in a manner whereby they are centered around said central object and positioned further outwards as the distance from the central object increases. The distance relationships of each object and message with respect to the central object can thus be grasped easily in a single view to thus make the debugging efficient.
The eight illustrative implementation is a debugging support device for supporting the debugging of an object-oriented program containing one or more objects, each of said objects having a sending means which sends messages between said objects, and a receiving means which receives said messages, being characterized by comprising; a designation means, which designates a desired object among said objects of said object-oriented program to be the central object to be targeted for said debugging, and a debugger object, which records said messages, and each of said objects comprising; a retaining part, which retains an index that indicates the distance of said message from said central object, an initializing means, which sets a prescribed index as said index at said retaining part of said central object, a deleting part, which, when the process requested by said message corresponding to said index retained has been completed, deletes the corresponding index, a second sending means which, when said message with said index is received or sent, sends the corresponding message to said debugger object, an adjusting part which adjusts said index in a fixed direction, an attaching means which attaches said adjusted index to the message sent to other said objects, and a restricting means which detects that said index has reached a prescribed limit value and stops said attachment of said adjusted index to said message.
The debugging support method of the eigth illustrative implementation supports the debugging of an object-oriented program containing one or more objects, each of said objects performing a sending process by which messages are sent between said objects and a receiving process by which said messages are received, by using a designation process by which a desired object is designated from among said objects of said object-oriented program to be the central object to be targeted for said debugging, using a debugger object for recording said messages, and each of said objects performing; a retaining process by which an index indicating the distance of said message from said central object is retained, an initializing process by which the retaining process of said central object is controlled so that a prescribed index is retained as said index, a deleting process by which, when a process requested by said message corresponding to said retained index has been completed, the corresponding index is deleted, a second sending process by which, when said message with said index is received or sent, the corresponding message is sent to said debugger object, an adjusting process by which said index is adjusted in a fixed direction, an attaching process by which said adjusted index is attached to the message sent to other said objects, and a restricting process by which said attachment of said adjusted index to said message is stopped upon detecting that said index has reached a prescribed limit value.
With the eight illustrative implementation and its method, when an index for distance is set for the central object, an index for distance is attached to the message sent from the central object. At the object receiving the message, the received index is adjusted in a fixed direction and attached to a message and sent to another subsequent object. The message index is thus adjusted as the sending of messages is repeated and the distance from the central object increases. When the index reaches a prescribed limit, the index is no longer attached to messages sent to further objects. Since only the messages with the index is sent from each object to the debugger object and recorded, the recorded messages are restricted to those for which the distance from the central object is within a certain range.
With the eighth illustrative implementation and its method, the composition is made easy since whether or not a message is recorded is determined autonomously by the organic interaction of each object.
The ninth illustrative implementation augments the eigth illustrative implementation by including: a destination designation means, which designates said debugger object, and a transmission means, which sequentially transmits an identifier, that indicates said designated debugger object, along with said index between each of said objects.
The debugging support method of the ninth illustrative implementation includes: a designation process by which said debugger object is designated and a transmission process by which an identifier indicating said designated debugger object is transmitted sequentially along with said index between each of said objects.
With the ninth illustrative implementation and its method, the composition is made easy since an identifier, that describes the destination of a message, is transmitted sequentially along with the index to enable the destination of a message to be judged easily just from within each object.
A first enhanced debugging method according to the present invention restricts a specified part in an object-oriented program targeted for debugging as a debug target zone and recording messages sent and received by objects contained within said restricted debug target zone.
The second enhanced debugging method augments the first enhanced debugging method by selecting an object arbitrarily from among objects comprising said object-oriented program to be a debug target and, when another object relevant to the actions of said selected object is to be included within said debug target area, a numeral within a prescribed range is attached to said another object.
The tenth illustrative implementation is a debugging support device equipped with a debugger object, which is an object that records messages sent and received by objects within an object-oriented program, said debugging support device being further equipped with: a first designation means, which designates an object, that is arbitrarily selected from among objects comprising said object-oriented program, to be a debug target object, a second designation means, which designates other objects, relevant to said object designated as the debug target object, as being in the debug target range along with said object, a collection means, which records messages, sent and received by each object included in the debug target range, according to each object, a cancellation means, which when the collection of messages have been completed, removes and cancels the targeting of the objects included in the debug target range for debugging, a storage means, which stores the contents designated by said second designation means, a first sending means, which sends messages from objects included within the debug target range, a receiving means, which receives messages sent to objects included with the debug target range, and a second sending means, which sends the contents of messages, received and sent by said receiving means and first sending means, to said debugger object.
The eleventh illustrative implementation augments the tenth illustrative implementation by equipping designation means with a range designation means which designates said debug target range by a numeral within a prescribed range.
The twelfth illustrative implementation augments the tenth illustrative implementation by equipping designation means with a destination designation means which designates, by the use of an unique identifier, said debugger object, which is to be the recording destination of messages sent and received by objects within said debug target range.
The thirteenth illustrative implementation augments the eleventh illustrative implementation so that the distances from said debug target object to each of the objects within said debug target range are designated by depth levels by which said distances are classified in a relative manner with the use of integers within a prescribed range.
The fourteenth illustrative implementation augments the thirteenth illustrative implementation so that said depth level takes on a prescribed limit value when said depth level is to indicate the furthest distance, within said debug target range, from said debug target object.
The fifteenth illustrative implementation augments the fourteenth illustrative implementation so that, when said identifier and said depth level within a prescribed range are registered within the storage means, said identifier and a new depth level, obtained by modifying said depth level, are attached to the contents of the message to be sent.
The sixteenth illustrative implementation augments the fifteenth illustrative implementation so that said new depth level is set to a value closer than the depth level before modification to the prescribed limit value, which is the depth level that indicates the furthest distance, within said debug target range, from said debug target object, by one step.
The seventeenth illustrative implementation augments the twelfth illustrative implementation so that, when said identifier and said depth level within a prescribed range are attached to the received message, said depth identifier and said depth level are removed form said message.
The eighteenth illustrative implementation augments the twelfth illustrative implementation so that, when said identifier and said said depth level within a prescribed range are registered in said storage means, the messages sent and received by objects within the debug target range are sent to the debugger object specified by said identifier.
The first and second enhanced debugging methods and the tenth through eighteenth illustrative implementations provide the following actions. That is, when debugging support is to be performed for an object-oriented program in a parallel processing system environment by using the debugging support method and device of the present invention, an arbitrary object comprising said program is designated as a debug target object before the execution of said program. Said program to be debugged is thus specified. Thereafter, said program is executed and the messages, exchanged between said debug target object and other objects (hereinafter referred to as relevant objects) relevant to the actions of said debug target object, are recorded in a debugger object specified by an unique identifier.
Here, if the debug target object belongs in common to a plurality of programs, the number of said relevant objects will increase. A vast amount of messages will thus be exchanged between said debug target object and said relevant objects. Moreover, since such relevant objects will include numerous objects which are not relevant to the program which was initially targeted for debugging, numerous event histories which are not necessary for the debugging operation will be recorded in the debugger object.
In the first enhanced debugging method, messages, which are relevant to the actions of the debug target object but are not relevant to the immediate debugging support work, are excluded to solve the problem described above. That is, a prescribed part of the program targeted for debugging is restricted as the debug target range and only the information sent to and received by objects within this debug target range are recorded in the debugger object. By doing so, one can concentrate on the actions of specific objects relevant to a specific program.
By the second enhanced debugging method, objects included in said debug target range are distinguished from objects outside said range. That is, if an object within the debugged program is to be included in the debug target range, a numerical value within a prescribed range is attached to this object.
The tenth illustrative implementation can implement the second enhanced debugging method. The following actions are provided by the various above-mentioned means.
[Before Program Execution]
A first designation means designates an object, that is arbitrarily selected from within the debugged program, as a debug target object. Next, a second designation means designates other objects relevant to the actions of said debug target object as being in the debug target range. To be more specific, in the eleventh illustrative implementation, a range designation means designates the debug target range with respect to said debug target object. Furthermore, in the twelfth illustrative implementation, a destination designation means designates the debugger object to which a message sent or received by an object designated to be in the debug target range should be sent. That is, when a plurality of debugger objects are activated, an unique identifier assigned to each debugger object is provided to said debug target object.
The debug target range designated by said range designation means is expressed in a relative manner by a numerical value within a prescribed range. In the thirteenth illustrative implementation, depth levels are used as this numerical value within a prescribed range. The depth levels are prescribed integer values which classify and express, in a relative manner, the distances from said debug target object to each of the objects within said debug target range.
An object-oriented program is executed by messages being handed sequentially from one object to the next object. When said debug target object is set as the starting point, said depth level designates how far an object may be from said debug target object, which serves as the starting point, to be set within said debug target range based on the process by which messages are handed sequentially to far objects.
In the fourteenth illustrative implementation, the depth level, that indicates the furthest debug target range from said starting-point debug target object, takes on a prescribed limit value. An object which is given this limit value is regarded to be of lowest priority as a debug target and depth levels are not given to objects that are positioned further away from this object and are outside the debug target range. This eliminates the need to be concerned with actions of objects that are unrelated to the current debugging operation.
When the specific designations necessary for the debugging operation are completed by the second designation means for said debug target object and for the objects within the debug target range as described above, the storage means registers said identifiers and depth levels. The debugging operation is controlled during the execution of the program according to the contents of these designations registered in the storage means. These actions shall now be described.
[During Program Execution]
During the execution of the program, the sending and receiving of various messages take place between objects. In the invention of claim 8, a message sending process is performed by said debug target object or each of the objects within the debug target range. That is, a first sending means first checks whether an identifier and a depth level are registered in said storage means. If both of these are registered in the storage means, it is then checked whether the registered depth level is the said limit value that indicates the furthest part of the debug target range and it is thereby judged whether the next object, which is to be the destination of the message, is within the debug target range.
If said depth level is the limit value, the next object which is to be the destination of a message is considered to be outside the debug target range. In this case, said message is sent as it is to the next object. On the other hand, if said depth level is not the limit value, the next object which is to be the destination of a message is considered to be still within the debug target range. In this case, a message, to which are attached the identifier registered in said storage means and a new depth level, obtained by modifying said depth level according to a prescribed procedure, is sent to the next object.
In the sixteenth illustrative implementation, each time a message is sent to the next object, the depth level to be attached to the message is modified to be closer to the limit value. The new depth level to be attached to said message is set to a value that is closer to said limit value than the depth level prior to modification by just one step. This means that the closer a depth level is to the limit value, the further away from the debug target object is the next object that is to be the destination of the message. The depth level value is modified in this manner to express the sequential lowering of priority of said next object as a debug target.
In the seventeenth illustrative implementation, a message receiving process is performed by said debug target object or each of the objects within the debug target range. That is, a receiving means checks whether the identifier and the modified depth level, which were attached by said first sending means, exist in the received message. If these do exist, these are removed from said message and the message is received. Furthermore, if there are no registered contents within the referenced storage means at this time, the identifier and the depth level removed from said message are stored in said storage means. These registered contents are used when a message is subsequently sent by the above-mentioned first sending means.
The identifier and the depth level registered in the storage means are also used in the debugging support process to control the recording of the event history. That is, in the eighteenth illustrative implementation, if and only if the identifier and the depth level are registered in the referenced storage means, a second sending means sends the event history to the debugger object specified by the registered identifier. Thus this enables only the messages sent and received by the designated debug target object and the objects within the designated debug target range to be sent to the designated debugger object. Meanwhile, a collection means records the sent messages according to object and in the order of time at the debugger object receiving the event history.
When the above series of processes are completed, a cancellation means deletes the identifier and the depth level registered in the storage means. The designation of the debug target range is thereby canceled automatically and a new debug target range can be designated in preparation for the next debugging support work.
Other and further objects, functions, and advantages of the present invention will be more fully understood by the following detailed description.